/*
 * XML Type:  BankResponseMessageSetV1
 * Namespace: http://ofx.net/types/2003/04
 * Java type: net.ofx.types.x2003.x04.BankResponseMessageSetV1
 *
 * Automatically generated - do not modify.
 */
package net.ofx.types.x2003.x04.impl;
/**
 * An XML BankResponseMessageSetV1(@http://ofx.net/types/2003/04).
 *
 * This is a complex type.
 */
public class BankResponseMessageSetV1Impl extends net.ofx.types.x2003.x04.impl.AbstractResponseMessageSetImpl implements net.ofx.types.x2003.x04.BankResponseMessageSetV1
{
    
    public BankResponseMessageSetV1Impl(org.apache.xmlbeans.SchemaType sType)
    {
        super(sType);
    }
    
    private static final javax.xml.namespace.QName STMTTRNRS$0 = 
        new javax.xml.namespace.QName("", "STMTTRNRS");
    private static final javax.xml.namespace.QName STMTENDTRNRS$2 = 
        new javax.xml.namespace.QName("", "STMTENDTRNRS");
    private static final javax.xml.namespace.QName INTRATRNRS$4 = 
        new javax.xml.namespace.QName("", "INTRATRNRS");
    private static final javax.xml.namespace.QName RECINTRATRNRS$6 = 
        new javax.xml.namespace.QName("", "RECINTRATRNRS");
    private static final javax.xml.namespace.QName STPCHKTRNRS$8 = 
        new javax.xml.namespace.QName("", "STPCHKTRNRS");
    private static final javax.xml.namespace.QName BANKMAILTRNRS$10 = 
        new javax.xml.namespace.QName("", "BANKMAILTRNRS");
    private static final javax.xml.namespace.QName BANKMAILSYNCRS$12 = 
        new javax.xml.namespace.QName("", "BANKMAILSYNCRS");
    private static final javax.xml.namespace.QName STPCHKSYNCRS$14 = 
        new javax.xml.namespace.QName("", "STPCHKSYNCRS");
    private static final javax.xml.namespace.QName INTRASYNCRS$16 = 
        new javax.xml.namespace.QName("", "INTRASYNCRS");
    private static final javax.xml.namespace.QName RECINTRASYNCRS$18 = 
        new javax.xml.namespace.QName("", "RECINTRASYNCRS");
    
    
    /**
     * Gets array of all "STMTTRNRS" elements
     */
    public net.ofx.types.x2003.x04.StatementTransactionResponse[] getSTMTTRNRSArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(STMTTRNRS$0, targetList);
            net.ofx.types.x2003.x04.StatementTransactionResponse[] result = new net.ofx.types.x2003.x04.StatementTransactionResponse[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "STMTTRNRS" element
     */
    public net.ofx.types.x2003.x04.StatementTransactionResponse getSTMTTRNRSArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.StatementTransactionResponse target = null;
            target = (net.ofx.types.x2003.x04.StatementTransactionResponse)get_store().find_element_user(STMTTRNRS$0, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "STMTTRNRS" element
     */
    public int sizeOfSTMTTRNRSArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(STMTTRNRS$0);
        }
    }
    
    /**
     * Sets array of all "STMTTRNRS" element
     */
    public void setSTMTTRNRSArray(net.ofx.types.x2003.x04.StatementTransactionResponse[] stmttrnrsArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(stmttrnrsArray, STMTTRNRS$0);
        }
    }
    
    /**
     * Sets ith "STMTTRNRS" element
     */
    public void setSTMTTRNRSArray(int i, net.ofx.types.x2003.x04.StatementTransactionResponse stmttrnrs)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.StatementTransactionResponse target = null;
            target = (net.ofx.types.x2003.x04.StatementTransactionResponse)get_store().find_element_user(STMTTRNRS$0, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(stmttrnrs);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "STMTTRNRS" element
     */
    public net.ofx.types.x2003.x04.StatementTransactionResponse insertNewSTMTTRNRS(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.StatementTransactionResponse target = null;
            target = (net.ofx.types.x2003.x04.StatementTransactionResponse)get_store().insert_element_user(STMTTRNRS$0, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "STMTTRNRS" element
     */
    public net.ofx.types.x2003.x04.StatementTransactionResponse addNewSTMTTRNRS()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.StatementTransactionResponse target = null;
            target = (net.ofx.types.x2003.x04.StatementTransactionResponse)get_store().add_element_user(STMTTRNRS$0);
            return target;
        }
    }
    
    /**
     * Removes the ith "STMTTRNRS" element
     */
    public void removeSTMTTRNRS(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(STMTTRNRS$0, i);
        }
    }
    
    /**
     * Gets array of all "STMTENDTRNRS" elements
     */
    public net.ofx.types.x2003.x04.StatementEndTransactionResponse[] getSTMTENDTRNRSArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(STMTENDTRNRS$2, targetList);
            net.ofx.types.x2003.x04.StatementEndTransactionResponse[] result = new net.ofx.types.x2003.x04.StatementEndTransactionResponse[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "STMTENDTRNRS" element
     */
    public net.ofx.types.x2003.x04.StatementEndTransactionResponse getSTMTENDTRNRSArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.StatementEndTransactionResponse target = null;
            target = (net.ofx.types.x2003.x04.StatementEndTransactionResponse)get_store().find_element_user(STMTENDTRNRS$2, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "STMTENDTRNRS" element
     */
    public int sizeOfSTMTENDTRNRSArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(STMTENDTRNRS$2);
        }
    }
    
    /**
     * Sets array of all "STMTENDTRNRS" element
     */
    public void setSTMTENDTRNRSArray(net.ofx.types.x2003.x04.StatementEndTransactionResponse[] stmtendtrnrsArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(stmtendtrnrsArray, STMTENDTRNRS$2);
        }
    }
    
    /**
     * Sets ith "STMTENDTRNRS" element
     */
    public void setSTMTENDTRNRSArray(int i, net.ofx.types.x2003.x04.StatementEndTransactionResponse stmtendtrnrs)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.StatementEndTransactionResponse target = null;
            target = (net.ofx.types.x2003.x04.StatementEndTransactionResponse)get_store().find_element_user(STMTENDTRNRS$2, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(stmtendtrnrs);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "STMTENDTRNRS" element
     */
    public net.ofx.types.x2003.x04.StatementEndTransactionResponse insertNewSTMTENDTRNRS(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.StatementEndTransactionResponse target = null;
            target = (net.ofx.types.x2003.x04.StatementEndTransactionResponse)get_store().insert_element_user(STMTENDTRNRS$2, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "STMTENDTRNRS" element
     */
    public net.ofx.types.x2003.x04.StatementEndTransactionResponse addNewSTMTENDTRNRS()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.StatementEndTransactionResponse target = null;
            target = (net.ofx.types.x2003.x04.StatementEndTransactionResponse)get_store().add_element_user(STMTENDTRNRS$2);
            return target;
        }
    }
    
    /**
     * Removes the ith "STMTENDTRNRS" element
     */
    public void removeSTMTENDTRNRS(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(STMTENDTRNRS$2, i);
        }
    }
    
    /**
     * Gets array of all "INTRATRNRS" elements
     */
    public net.ofx.types.x2003.x04.IntraTransactionResponse[] getINTRATRNRSArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(INTRATRNRS$4, targetList);
            net.ofx.types.x2003.x04.IntraTransactionResponse[] result = new net.ofx.types.x2003.x04.IntraTransactionResponse[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "INTRATRNRS" element
     */
    public net.ofx.types.x2003.x04.IntraTransactionResponse getINTRATRNRSArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.IntraTransactionResponse target = null;
            target = (net.ofx.types.x2003.x04.IntraTransactionResponse)get_store().find_element_user(INTRATRNRS$4, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "INTRATRNRS" element
     */
    public int sizeOfINTRATRNRSArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(INTRATRNRS$4);
        }
    }
    
    /**
     * Sets array of all "INTRATRNRS" element
     */
    public void setINTRATRNRSArray(net.ofx.types.x2003.x04.IntraTransactionResponse[] intratrnrsArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(intratrnrsArray, INTRATRNRS$4);
        }
    }
    
    /**
     * Sets ith "INTRATRNRS" element
     */
    public void setINTRATRNRSArray(int i, net.ofx.types.x2003.x04.IntraTransactionResponse intratrnrs)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.IntraTransactionResponse target = null;
            target = (net.ofx.types.x2003.x04.IntraTransactionResponse)get_store().find_element_user(INTRATRNRS$4, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(intratrnrs);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "INTRATRNRS" element
     */
    public net.ofx.types.x2003.x04.IntraTransactionResponse insertNewINTRATRNRS(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.IntraTransactionResponse target = null;
            target = (net.ofx.types.x2003.x04.IntraTransactionResponse)get_store().insert_element_user(INTRATRNRS$4, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "INTRATRNRS" element
     */
    public net.ofx.types.x2003.x04.IntraTransactionResponse addNewINTRATRNRS()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.IntraTransactionResponse target = null;
            target = (net.ofx.types.x2003.x04.IntraTransactionResponse)get_store().add_element_user(INTRATRNRS$4);
            return target;
        }
    }
    
    /**
     * Removes the ith "INTRATRNRS" element
     */
    public void removeINTRATRNRS(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(INTRATRNRS$4, i);
        }
    }
    
    /**
     * Gets array of all "RECINTRATRNRS" elements
     */
    public net.ofx.types.x2003.x04.RecurringIntraTransactionResponse[] getRECINTRATRNRSArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(RECINTRATRNRS$6, targetList);
            net.ofx.types.x2003.x04.RecurringIntraTransactionResponse[] result = new net.ofx.types.x2003.x04.RecurringIntraTransactionResponse[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "RECINTRATRNRS" element
     */
    public net.ofx.types.x2003.x04.RecurringIntraTransactionResponse getRECINTRATRNRSArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.RecurringIntraTransactionResponse target = null;
            target = (net.ofx.types.x2003.x04.RecurringIntraTransactionResponse)get_store().find_element_user(RECINTRATRNRS$6, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "RECINTRATRNRS" element
     */
    public int sizeOfRECINTRATRNRSArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(RECINTRATRNRS$6);
        }
    }
    
    /**
     * Sets array of all "RECINTRATRNRS" element
     */
    public void setRECINTRATRNRSArray(net.ofx.types.x2003.x04.RecurringIntraTransactionResponse[] recintratrnrsArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(recintratrnrsArray, RECINTRATRNRS$6);
        }
    }
    
    /**
     * Sets ith "RECINTRATRNRS" element
     */
    public void setRECINTRATRNRSArray(int i, net.ofx.types.x2003.x04.RecurringIntraTransactionResponse recintratrnrs)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.RecurringIntraTransactionResponse target = null;
            target = (net.ofx.types.x2003.x04.RecurringIntraTransactionResponse)get_store().find_element_user(RECINTRATRNRS$6, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(recintratrnrs);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "RECINTRATRNRS" element
     */
    public net.ofx.types.x2003.x04.RecurringIntraTransactionResponse insertNewRECINTRATRNRS(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.RecurringIntraTransactionResponse target = null;
            target = (net.ofx.types.x2003.x04.RecurringIntraTransactionResponse)get_store().insert_element_user(RECINTRATRNRS$6, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "RECINTRATRNRS" element
     */
    public net.ofx.types.x2003.x04.RecurringIntraTransactionResponse addNewRECINTRATRNRS()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.RecurringIntraTransactionResponse target = null;
            target = (net.ofx.types.x2003.x04.RecurringIntraTransactionResponse)get_store().add_element_user(RECINTRATRNRS$6);
            return target;
        }
    }
    
    /**
     * Removes the ith "RECINTRATRNRS" element
     */
    public void removeRECINTRATRNRS(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(RECINTRATRNRS$6, i);
        }
    }
    
    /**
     * Gets array of all "STPCHKTRNRS" elements
     */
    public net.ofx.types.x2003.x04.StopCheckTransactionResponse[] getSTPCHKTRNRSArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(STPCHKTRNRS$8, targetList);
            net.ofx.types.x2003.x04.StopCheckTransactionResponse[] result = new net.ofx.types.x2003.x04.StopCheckTransactionResponse[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "STPCHKTRNRS" element
     */
    public net.ofx.types.x2003.x04.StopCheckTransactionResponse getSTPCHKTRNRSArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.StopCheckTransactionResponse target = null;
            target = (net.ofx.types.x2003.x04.StopCheckTransactionResponse)get_store().find_element_user(STPCHKTRNRS$8, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "STPCHKTRNRS" element
     */
    public int sizeOfSTPCHKTRNRSArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(STPCHKTRNRS$8);
        }
    }
    
    /**
     * Sets array of all "STPCHKTRNRS" element
     */
    public void setSTPCHKTRNRSArray(net.ofx.types.x2003.x04.StopCheckTransactionResponse[] stpchktrnrsArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(stpchktrnrsArray, STPCHKTRNRS$8);
        }
    }
    
    /**
     * Sets ith "STPCHKTRNRS" element
     */
    public void setSTPCHKTRNRSArray(int i, net.ofx.types.x2003.x04.StopCheckTransactionResponse stpchktrnrs)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.StopCheckTransactionResponse target = null;
            target = (net.ofx.types.x2003.x04.StopCheckTransactionResponse)get_store().find_element_user(STPCHKTRNRS$8, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(stpchktrnrs);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "STPCHKTRNRS" element
     */
    public net.ofx.types.x2003.x04.StopCheckTransactionResponse insertNewSTPCHKTRNRS(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.StopCheckTransactionResponse target = null;
            target = (net.ofx.types.x2003.x04.StopCheckTransactionResponse)get_store().insert_element_user(STPCHKTRNRS$8, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "STPCHKTRNRS" element
     */
    public net.ofx.types.x2003.x04.StopCheckTransactionResponse addNewSTPCHKTRNRS()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.StopCheckTransactionResponse target = null;
            target = (net.ofx.types.x2003.x04.StopCheckTransactionResponse)get_store().add_element_user(STPCHKTRNRS$8);
            return target;
        }
    }
    
    /**
     * Removes the ith "STPCHKTRNRS" element
     */
    public void removeSTPCHKTRNRS(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(STPCHKTRNRS$8, i);
        }
    }
    
    /**
     * Gets array of all "BANKMAILTRNRS" elements
     */
    public net.ofx.types.x2003.x04.BankMailTransactionResponse[] getBANKMAILTRNRSArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(BANKMAILTRNRS$10, targetList);
            net.ofx.types.x2003.x04.BankMailTransactionResponse[] result = new net.ofx.types.x2003.x04.BankMailTransactionResponse[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "BANKMAILTRNRS" element
     */
    public net.ofx.types.x2003.x04.BankMailTransactionResponse getBANKMAILTRNRSArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BankMailTransactionResponse target = null;
            target = (net.ofx.types.x2003.x04.BankMailTransactionResponse)get_store().find_element_user(BANKMAILTRNRS$10, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "BANKMAILTRNRS" element
     */
    public int sizeOfBANKMAILTRNRSArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(BANKMAILTRNRS$10);
        }
    }
    
    /**
     * Sets array of all "BANKMAILTRNRS" element
     */
    public void setBANKMAILTRNRSArray(net.ofx.types.x2003.x04.BankMailTransactionResponse[] bankmailtrnrsArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(bankmailtrnrsArray, BANKMAILTRNRS$10);
        }
    }
    
    /**
     * Sets ith "BANKMAILTRNRS" element
     */
    public void setBANKMAILTRNRSArray(int i, net.ofx.types.x2003.x04.BankMailTransactionResponse bankmailtrnrs)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BankMailTransactionResponse target = null;
            target = (net.ofx.types.x2003.x04.BankMailTransactionResponse)get_store().find_element_user(BANKMAILTRNRS$10, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(bankmailtrnrs);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "BANKMAILTRNRS" element
     */
    public net.ofx.types.x2003.x04.BankMailTransactionResponse insertNewBANKMAILTRNRS(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BankMailTransactionResponse target = null;
            target = (net.ofx.types.x2003.x04.BankMailTransactionResponse)get_store().insert_element_user(BANKMAILTRNRS$10, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "BANKMAILTRNRS" element
     */
    public net.ofx.types.x2003.x04.BankMailTransactionResponse addNewBANKMAILTRNRS()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BankMailTransactionResponse target = null;
            target = (net.ofx.types.x2003.x04.BankMailTransactionResponse)get_store().add_element_user(BANKMAILTRNRS$10);
            return target;
        }
    }
    
    /**
     * Removes the ith "BANKMAILTRNRS" element
     */
    public void removeBANKMAILTRNRS(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(BANKMAILTRNRS$10, i);
        }
    }
    
    /**
     * Gets array of all "BANKMAILSYNCRS" elements
     */
    public net.ofx.types.x2003.x04.BankMailSyncResponse[] getBANKMAILSYNCRSArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(BANKMAILSYNCRS$12, targetList);
            net.ofx.types.x2003.x04.BankMailSyncResponse[] result = new net.ofx.types.x2003.x04.BankMailSyncResponse[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "BANKMAILSYNCRS" element
     */
    public net.ofx.types.x2003.x04.BankMailSyncResponse getBANKMAILSYNCRSArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BankMailSyncResponse target = null;
            target = (net.ofx.types.x2003.x04.BankMailSyncResponse)get_store().find_element_user(BANKMAILSYNCRS$12, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "BANKMAILSYNCRS" element
     */
    public int sizeOfBANKMAILSYNCRSArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(BANKMAILSYNCRS$12);
        }
    }
    
    /**
     * Sets array of all "BANKMAILSYNCRS" element
     */
    public void setBANKMAILSYNCRSArray(net.ofx.types.x2003.x04.BankMailSyncResponse[] bankmailsyncrsArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(bankmailsyncrsArray, BANKMAILSYNCRS$12);
        }
    }
    
    /**
     * Sets ith "BANKMAILSYNCRS" element
     */
    public void setBANKMAILSYNCRSArray(int i, net.ofx.types.x2003.x04.BankMailSyncResponse bankmailsyncrs)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BankMailSyncResponse target = null;
            target = (net.ofx.types.x2003.x04.BankMailSyncResponse)get_store().find_element_user(BANKMAILSYNCRS$12, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(bankmailsyncrs);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "BANKMAILSYNCRS" element
     */
    public net.ofx.types.x2003.x04.BankMailSyncResponse insertNewBANKMAILSYNCRS(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BankMailSyncResponse target = null;
            target = (net.ofx.types.x2003.x04.BankMailSyncResponse)get_store().insert_element_user(BANKMAILSYNCRS$12, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "BANKMAILSYNCRS" element
     */
    public net.ofx.types.x2003.x04.BankMailSyncResponse addNewBANKMAILSYNCRS()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.BankMailSyncResponse target = null;
            target = (net.ofx.types.x2003.x04.BankMailSyncResponse)get_store().add_element_user(BANKMAILSYNCRS$12);
            return target;
        }
    }
    
    /**
     * Removes the ith "BANKMAILSYNCRS" element
     */
    public void removeBANKMAILSYNCRS(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(BANKMAILSYNCRS$12, i);
        }
    }
    
    /**
     * Gets array of all "STPCHKSYNCRS" elements
     */
    public net.ofx.types.x2003.x04.StopCheckSyncResponse[] getSTPCHKSYNCRSArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(STPCHKSYNCRS$14, targetList);
            net.ofx.types.x2003.x04.StopCheckSyncResponse[] result = new net.ofx.types.x2003.x04.StopCheckSyncResponse[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "STPCHKSYNCRS" element
     */
    public net.ofx.types.x2003.x04.StopCheckSyncResponse getSTPCHKSYNCRSArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.StopCheckSyncResponse target = null;
            target = (net.ofx.types.x2003.x04.StopCheckSyncResponse)get_store().find_element_user(STPCHKSYNCRS$14, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "STPCHKSYNCRS" element
     */
    public int sizeOfSTPCHKSYNCRSArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(STPCHKSYNCRS$14);
        }
    }
    
    /**
     * Sets array of all "STPCHKSYNCRS" element
     */
    public void setSTPCHKSYNCRSArray(net.ofx.types.x2003.x04.StopCheckSyncResponse[] stpchksyncrsArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(stpchksyncrsArray, STPCHKSYNCRS$14);
        }
    }
    
    /**
     * Sets ith "STPCHKSYNCRS" element
     */
    public void setSTPCHKSYNCRSArray(int i, net.ofx.types.x2003.x04.StopCheckSyncResponse stpchksyncrs)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.StopCheckSyncResponse target = null;
            target = (net.ofx.types.x2003.x04.StopCheckSyncResponse)get_store().find_element_user(STPCHKSYNCRS$14, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(stpchksyncrs);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "STPCHKSYNCRS" element
     */
    public net.ofx.types.x2003.x04.StopCheckSyncResponse insertNewSTPCHKSYNCRS(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.StopCheckSyncResponse target = null;
            target = (net.ofx.types.x2003.x04.StopCheckSyncResponse)get_store().insert_element_user(STPCHKSYNCRS$14, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "STPCHKSYNCRS" element
     */
    public net.ofx.types.x2003.x04.StopCheckSyncResponse addNewSTPCHKSYNCRS()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.StopCheckSyncResponse target = null;
            target = (net.ofx.types.x2003.x04.StopCheckSyncResponse)get_store().add_element_user(STPCHKSYNCRS$14);
            return target;
        }
    }
    
    /**
     * Removes the ith "STPCHKSYNCRS" element
     */
    public void removeSTPCHKSYNCRS(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(STPCHKSYNCRS$14, i);
        }
    }
    
    /**
     * Gets array of all "INTRASYNCRS" elements
     */
    public net.ofx.types.x2003.x04.IntraSyncResponse[] getINTRASYNCRSArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(INTRASYNCRS$16, targetList);
            net.ofx.types.x2003.x04.IntraSyncResponse[] result = new net.ofx.types.x2003.x04.IntraSyncResponse[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "INTRASYNCRS" element
     */
    public net.ofx.types.x2003.x04.IntraSyncResponse getINTRASYNCRSArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.IntraSyncResponse target = null;
            target = (net.ofx.types.x2003.x04.IntraSyncResponse)get_store().find_element_user(INTRASYNCRS$16, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "INTRASYNCRS" element
     */
    public int sizeOfINTRASYNCRSArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(INTRASYNCRS$16);
        }
    }
    
    /**
     * Sets array of all "INTRASYNCRS" element
     */
    public void setINTRASYNCRSArray(net.ofx.types.x2003.x04.IntraSyncResponse[] intrasyncrsArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(intrasyncrsArray, INTRASYNCRS$16);
        }
    }
    
    /**
     * Sets ith "INTRASYNCRS" element
     */
    public void setINTRASYNCRSArray(int i, net.ofx.types.x2003.x04.IntraSyncResponse intrasyncrs)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.IntraSyncResponse target = null;
            target = (net.ofx.types.x2003.x04.IntraSyncResponse)get_store().find_element_user(INTRASYNCRS$16, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(intrasyncrs);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "INTRASYNCRS" element
     */
    public net.ofx.types.x2003.x04.IntraSyncResponse insertNewINTRASYNCRS(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.IntraSyncResponse target = null;
            target = (net.ofx.types.x2003.x04.IntraSyncResponse)get_store().insert_element_user(INTRASYNCRS$16, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "INTRASYNCRS" element
     */
    public net.ofx.types.x2003.x04.IntraSyncResponse addNewINTRASYNCRS()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.IntraSyncResponse target = null;
            target = (net.ofx.types.x2003.x04.IntraSyncResponse)get_store().add_element_user(INTRASYNCRS$16);
            return target;
        }
    }
    
    /**
     * Removes the ith "INTRASYNCRS" element
     */
    public void removeINTRASYNCRS(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(INTRASYNCRS$16, i);
        }
    }
    
    /**
     * Gets array of all "RECINTRASYNCRS" elements
     */
    public net.ofx.types.x2003.x04.RecurringIntraSyncResponse[] getRECINTRASYNCRSArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(RECINTRASYNCRS$18, targetList);
            net.ofx.types.x2003.x04.RecurringIntraSyncResponse[] result = new net.ofx.types.x2003.x04.RecurringIntraSyncResponse[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "RECINTRASYNCRS" element
     */
    public net.ofx.types.x2003.x04.RecurringIntraSyncResponse getRECINTRASYNCRSArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.RecurringIntraSyncResponse target = null;
            target = (net.ofx.types.x2003.x04.RecurringIntraSyncResponse)get_store().find_element_user(RECINTRASYNCRS$18, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "RECINTRASYNCRS" element
     */
    public int sizeOfRECINTRASYNCRSArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(RECINTRASYNCRS$18);
        }
    }
    
    /**
     * Sets array of all "RECINTRASYNCRS" element
     */
    public void setRECINTRASYNCRSArray(net.ofx.types.x2003.x04.RecurringIntraSyncResponse[] recintrasyncrsArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(recintrasyncrsArray, RECINTRASYNCRS$18);
        }
    }
    
    /**
     * Sets ith "RECINTRASYNCRS" element
     */
    public void setRECINTRASYNCRSArray(int i, net.ofx.types.x2003.x04.RecurringIntraSyncResponse recintrasyncrs)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.RecurringIntraSyncResponse target = null;
            target = (net.ofx.types.x2003.x04.RecurringIntraSyncResponse)get_store().find_element_user(RECINTRASYNCRS$18, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(recintrasyncrs);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "RECINTRASYNCRS" element
     */
    public net.ofx.types.x2003.x04.RecurringIntraSyncResponse insertNewRECINTRASYNCRS(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.RecurringIntraSyncResponse target = null;
            target = (net.ofx.types.x2003.x04.RecurringIntraSyncResponse)get_store().insert_element_user(RECINTRASYNCRS$18, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "RECINTRASYNCRS" element
     */
    public net.ofx.types.x2003.x04.RecurringIntraSyncResponse addNewRECINTRASYNCRS()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.RecurringIntraSyncResponse target = null;
            target = (net.ofx.types.x2003.x04.RecurringIntraSyncResponse)get_store().add_element_user(RECINTRASYNCRS$18);
            return target;
        }
    }
    
    /**
     * Removes the ith "RECINTRASYNCRS" element
     */
    public void removeRECINTRASYNCRS(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(RECINTRASYNCRS$18, i);
        }
    }
}
